package com.witdata.common.util;

import com.alibaba.fastjson2.JSON;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.io.Serial;
import java.io.Serializable;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
@Slf4j
public class RedisUtils implements Serializable {

    private final RedisTemplate<String, String> redisTemplate;

    @Serial
    private static final long serialVersionUID = 1L;

    /**
     * 缓存基本的对象。
     * @param key 缓存的键值
     * @param value 缓存的值
     */
    public <T> void setCacheObject(final String key, final T value){
        String json = JSON.toJSONString(value);
        redisTemplate.opsForValue().set(key, json);
    }

    /**
     * 缓存基本的对象。
     * @param key 缓存的键值
     * @param value 缓存的值
     * @param timeout 时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
    {
        String json = JSON.toJSONString(value);
        redisTemplate.opsForValue().set(key, json, timeout, timeUnit);
    }

//    /**
//     * 设置有效时间(分)。
//     *
//     * @param key Redis键
//     * @param timeout 超时时间
//     * @return true=设置成功；false=设置失败
//     */
//    public boolean expire(final String key, final long timeout)
//    {
//        return expire(key, timeout, TimeUnit.SECONDS);
//    }

//    /**
//     * 设置有效时间。
//     * @param key Redis键
//     * @param timeout 超时时间
//     * @param unit 时间单位
//     * @return true=设置成功；false=设置失败
//     */
//    public boolean expire(final String key, final long timeout, final TimeUnit unit)
//    {
//        return Boolean.TRUE.equals(redisTemplate.expire(key, timeout, unit));
//    }

    /**
     * 获得缓存的基本对象。
     * @param key 缓存键值
     * @return 缓存键值对应的数据
     */
    public <T> T getCacheObject(final String key, final Class<T> clazz)
    {
        try {
            ValueOperations<String, String> operations = redisTemplate.opsForValue();
            String json = operations.get(key);
            return JSON.parseObject(json, clazz);
        } catch (SerializationException e) {
            log.error(e.getMessage());
            log.error("Redis反序列化失败!");
        }
        return null;
    }

    /**
     * 删除单个对象
     * @param key 缓存的键值
     */
    public boolean deleteObject(final String key)
    {
        return Boolean.TRUE.equals(redisTemplate.delete(key));
    }

//    /**
//     * 模糊删除key
//     * @param prefix 键值前缀
//     */
//    public boolean deleteByPrefix(final String prefix)
//    {
//        Set<String> keys = redisTemplate.keys(prefix);
//        if(!CollectionUtils.isEmpty(keys)){
//            redisTemplate.delete(keys);
//        }
//        return true;
//    }

//    /**
//     * 缓存List数据
//     * @param key 缓存的键值
//     * @param dataList 待缓存的List数据
//     * @return 缓存的对象
//     */
//    public <T> long setCacheList(final String key, final List<T> dataList)
//    {
//        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
//        return count == null ? 0 : count;
//    }

//    /**
//     * 获得缓存的list对象
//     *
//     * @param key 缓存的键值
//     * @return 缓存键值对应的数据
//     */
//    public Object getCacheList(final String key)
//    {
//        return redisTemplate.opsForList().range(key, 0, -1);
//    }


    @Autowired
    public RedisUtils(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
}
